home *** CD-ROM | disk | FTP | other *** search
/ Atari Mega Archive 1 / Atari Mega Archive - Volume 1.iso / lists / mint / l_0799 / 575 < prev    next >
Encoding:
Internet Message Format  |  1994-08-27  |  10.4 KB
  1. From: Kay Roemer <roemer@informatik.uni-frankfurt.de>
  2. Posted-Date: Mon, 25 Oct 93 8:10:32 MEZ
  3. Received-Date: Mon, 25 Oct 93 08:10:32 +0100
  4. Message-Id: <9310250710.AA22270@hera.rbi.informatik.uni-frankfurt.de>
  5. Subject: fselect() ...
  6. To: mint@atari.archive.umich.edu
  7. Date: Mon, 25 Oct 93 8:10:32 MEZ
  8. Mailer: Elm [revision: 70.85]
  9.  
  10. These diffs make Fselect() work for multiple
  11. processes selecting on the same file.
  12.  
  13. The diffs are relative to 1.09 with my sleep()
  14. patches already applied (look at my previous
  15. message, the new Fselect() will only work with
  16. the patched sleep()).
  17.  
  18. Cheers -- Kay.
  19.  
  20. *** ../new/biosfs.c    Fri Oct 22 20:58:26 1993
  21. --- biosfs.c    Mon Sep 13 21:41:28 1993
  22. ***************
  23. *** 1236,1243 ****
  24.           }
  25.           if (tty) {
  26.           /* avoid collisions with other processes */
  27. !             if (!tty->rsel)
  28. !                 tty->rsel = p;
  29.           }
  30.           return 0;
  31.       } else if (mode == O_WRONLY) {
  32. --- 1240,1248 ----
  33.           }
  34.           if (tty) {
  35.           /* avoid collisions with other processes */
  36. !             if (tty->rsel)
  37. !                 return 2; /* collsion */
  38. !             tty->rsel = p;
  39.           }
  40.           return 0;
  41.       } else if (mode == O_WRONLY) {
  42. ***************
  43. *** 1246,1253 ****
  44.               return 1;
  45.           }
  46.           if (tty) {
  47. !             if (!tty->wsel)
  48. !                 tty->wsel = p;
  49.           }
  50.           return 0;
  51.       }
  52. --- 1251,1259 ----
  53.               return 1;
  54.           }
  55.           if (tty) {
  56. !             if (tty->wsel)
  57. !                 return 2; /* collision */
  58. !             tty->wsel = p;
  59.           }
  60.           return 0;
  61.       }
  62. ***************
  63. *** 1482,1489 ****
  64.       if (mousetail - mousehead)
  65.           return 1;    /* input waiting already */
  66.   
  67. !     if (!mousersel)
  68. !         mousersel = p;
  69.       return 0;
  70.   }
  71.   
  72. --- 1488,1496 ----
  73.       if (mousetail - mousehead)
  74.           return 1;    /* input waiting already */
  75.   
  76. !     if (mousersel)
  77. !         return 2; /* collision */
  78. !     mousersel = p;
  79.       return 0;
  80.   }
  81.   
  82. *** ../new/dosfile.c    Fri Oct 22 20:58:26 1993
  83. --- dosfile.c    Fri Oct 22 19:11:58 1993
  84. ***************
  85. *** 11,16 ****
  86. --- 11,19 ----
  87.   static long do_dup P_((int,int));
  88.   static void unselectme P_((PROC *));
  89.   
  90. + /* wait condition for selecting processes which got collisions */
  91. + short select_coll;
  92. + 
  93.   /*
  94.    * first, some utility routines
  95.    */
  96. ***************
  97. *** 274,279 ****
  98. --- 277,284 ----
  99.       if (f->dev) {
  100.           (*f->dev->unselect)(f, (long)p, O_RDONLY);
  101.           (*f->dev->unselect)(f, (long)p, O_WRONLY);
  102. + /* give other processes a chance to select on this file */
  103. +         wake(SELECT_Q, (long)&select_coll);
  104.       }
  105.   
  106.       f->links--;
  107. ***************
  108. *** 957,983 ****
  109.       unsigned timeout;
  110.       long *rfdp, *wfdp, *xfdp;
  111.   {
  112. !     long rfd, wfd;
  113.       long mask, bytes;
  114.       int i, count;
  115.       FILEPTR *f;
  116.       PROC *p;
  117. !     TIMEOUT *t;
  118.       short sr;
  119.   
  120.       if (xfdp)
  121.           *xfdp = 0;
  122.   
  123.       if (rfdp) {
  124. !         rfd = *rfdp; *rfdp = 0;
  125.       }
  126.       else
  127. !         rfd = 0;
  128.       if (wfdp) {
  129. !         wfd = *wfdp; *wfdp = 0;
  130.       }
  131.       else
  132. !         wfd = 0;
  133.   
  134.       TRACE(("Fselect(%u, %lx, %lx)", timeout, rfd, wfd));
  135.       p = curproc;            /* help the optimizer out */
  136. --- 962,988 ----
  137.       unsigned timeout;
  138.       long *rfdp, *wfdp, *xfdp;
  139.   {
  140. !     long rfd, wfd, orfd, owfd;
  141.       long mask, bytes;
  142.       int i, count;
  143.       FILEPTR *f;
  144.       PROC *p;
  145. !     TIMEOUT *t = 0;
  146.       short sr;
  147.   
  148.       if (xfdp)
  149.           *xfdp = 0;
  150.   
  151.       if (rfdp) {
  152. !         orfd = rfd = *rfdp; *rfdp = 0;
  153.       }
  154.       else
  155. !         orfd = rfd = 0;
  156.       if (wfdp) {
  157. !         owfd = wfd = *wfdp; *wfdp = 0;
  158.       }
  159.       else
  160. !         owfd = wfd = 0;
  161.   
  162.       TRACE(("Fselect(%u, %lx, %lx)", timeout, rfd, wfd));
  163.       p = curproc;            /* help the optimizer out */
  164. ***************
  165. *** 985,991 ****
  166.       /* first, validate the masks */
  167.       mask = 1L;
  168.       for (i = 0; i < MAX_OPEN; i++) {
  169. !         if ( ((rfd & mask) || (wfd & mask)) && !(p->handle[i]) ) {
  170.               DEBUG(("Fselect: invalid handle: %d", i));
  171.               return EIHNDL;
  172.           }
  173. --- 990,996 ----
  174.       /* first, validate the masks */
  175.       mask = 1L;
  176.       for (i = 0; i < MAX_OPEN; i++) {
  177. !         if ( ((orfd & mask) || (owfd & mask)) && !(p->handle[i]) ) {
  178.               DEBUG(("Fselect: invalid handle: %d", i));
  179.               return EIHNDL;
  180.           }
  181. ***************
  182. *** 1001,1043 ****
  183.    * closed one of the handles.
  184.    */
  185.   
  186. -     mask = 1L;
  187.       count = 0;
  188.       curproc->wait_cond = (long)wakeselect;        /* flag */
  189.   
  190.       for (i = 0; i < MAX_OPEN; i++) {
  191.           if (rfd & mask) {
  192.               f = p->handle[i];
  193. !             if ((*f->dev->select)(f, (long)p, O_RDONLY)) {
  194.                   count++;
  195.                   *rfdp |= mask;
  196.               }
  197.           }
  198.           if (wfd & mask) {
  199.               f = p->handle[i];
  200. !             if ((*f->dev->select)(f, (long)p, O_WRONLY)) {
  201.                   count++;
  202.                   *wfdp |= mask;
  203.               }
  204.           }
  205.           mask = mask << 1L;
  206.       }
  207.   
  208.       if (count == 0) {
  209. !         /* OK, now let's set a timeout */
  210.   
  211. !         if (timeout) {
  212.               t = addtimeout((long)timeout, unselectme);
  213. -         } else {
  214. -             t = 0;
  215.           }
  216.   
  217.           sr = spl7();
  218.   
  219.       /* curproc->wait_cond changes when data arrives or the timeout happens */
  220.           while (curproc->wait_cond == (long)wakeselect) {
  221.               TRACE(("sleeping in Fselect"));
  222. !             sleep(SELECT_Q, (long)wakeselect);
  223.           }
  224.           spl(sr);
  225.   
  226. --- 1006,1075 ----
  227.    * closed one of the handles.
  228.    */
  229.   
  230.       count = 0;
  231.       curproc->wait_cond = (long)wakeselect;        /* flag */
  232.   
  233. + 
  234. + /* NOTE to the above note: since we can get here several times (in
  235. +  * case of collisions) after we've gone to sleep, we probably cannot
  236. +  * assume the filepointers are valid.
  237. +  * I'm not really sure, because `post_sig' sets curproc->wait_cond
  238. +  * to zero and then we cannot get here after we've gone to sleep. 
  239. +  */
  240. +  
  241. + retry_after_collision:
  242. +     mask = 1L;
  243. +     
  244.       for (i = 0; i < MAX_OPEN; i++) {
  245.           if (rfd & mask) {
  246.               f = p->handle[i];
  247. !             if (f) {
  248. !                 switch ((*f->dev->select)(f, (long)p, O_RDONLY)) {
  249. !                 case 1:
  250.                   count++;
  251.                   *rfdp |= mask;
  252. +                 case 0:
  253. +                 rfd &= ~mask;
  254. +                 }
  255.               }
  256.           }
  257.           if (wfd & mask) {
  258.               f = p->handle[i];
  259. !             if (f) {
  260. !                 switch ((*f->dev->select)(f, (long)p, O_WRONLY)) {
  261. !                 case 1:
  262.                   count++;
  263.                   *wfdp |= mask;
  264. +                 case 0:
  265. +                 wfd &= ~mask;
  266. +                 }
  267.               }
  268.           }
  269.           mask = mask << 1L;
  270.       }
  271.   
  272.       if (count == 0) {
  273. !     /* OK, now let's set a timeout, but only the first time we get here */
  274.   
  275. !         if (!t && timeout) {
  276.               t = addtimeout((long)timeout, unselectme);
  277.           }
  278.   
  279.           sr = spl7();
  280.   
  281.       /* curproc->wait_cond changes when data arrives or the timeout happens */
  282.           while (curproc->wait_cond == (long)wakeselect) {
  283. +             long cond = (rfd || wfd) ? (long)&select_coll
  284. +                          : (long)wakeselect;
  285. +                          
  286.               TRACE(("sleeping in Fselect"));
  287. !             if (sleep(SELECT_Q, cond))
  288. !                 curproc->wait_cond = 0;
  289. !         }
  290. !         if (curproc->wait_cond == (long)&select_coll) {
  291. !             curproc->wait_cond = (long)wakeselect;
  292. !             spl(sr);
  293. !             goto retry_after_collision;
  294.           }
  295.           spl(sr);
  296.   
  297. ***************
  298. *** 1047,1053 ****
  299.       /* OK, let's see what data arrived (if any) */
  300.           mask = 1L;
  301.           for (i = 0; i < MAX_OPEN; i++) {
  302. !             if (rfd & mask) {
  303.                   f = p->handle[i];
  304.                   if (f) {
  305.                       bytes = 1L;
  306. --- 1079,1085 ----
  307.       /* OK, let's see what data arrived (if any) */
  308.           mask = 1L;
  309.           for (i = 0; i < MAX_OPEN; i++) {
  310. !             if (orfd & mask) {
  311.                   f = p->handle[i];
  312.                   if (f) {
  313.                       bytes = 1L;
  314. ***************
  315. *** 1058,1064 ****
  316.                       }
  317.                   }
  318.               }
  319. !             if (wfd & mask) {
  320.                   f = p->handle[i];
  321.                   if (f) {
  322.                       bytes = 1L;
  323. --- 1090,1096 ----
  324.                       }
  325.                   }
  326.               }
  327. !             if (owfd & mask) {
  328.                   f = p->handle[i];
  329.                   if (f) {
  330.                       bytes = 1L;
  331. ***************
  332. *** 1071,1089 ****
  333.               }
  334.               mask = mask << 1L;
  335.           }
  336. !     }
  337.   
  338.       /* at this point, we either have data or a time out */
  339.       /* cancel all the selects */
  340.       mask = 1L;
  341.   
  342.       for (i = 0; i < MAX_OPEN; i++) {
  343. !         if (rfd & mask) {
  344.               f = p->handle[i];
  345.               if (f)
  346.                   (*f->dev->unselect)(f, (long)p, O_RDONLY);
  347.           }
  348. !         if (wfd & mask) {
  349.               f = p->handle[i];
  350.               if (f)
  351.                   (*f->dev->unselect)(f, (long)p, O_WRONLY);
  352. --- 1103,1127 ----
  353.               }
  354.               mask = mask << 1L;
  355.           }
  356. !     } else if (t) {
  357.   
  358. +     /* in case data arrived after a collsion, there
  359. +      * could be a timeout pending even if count > 0
  360. +      */
  361. +         canceltimeout(t);
  362. +     }
  363. +     
  364.       /* at this point, we either have data or a time out */
  365.       /* cancel all the selects */
  366.       mask = 1L;
  367.   
  368.       for (i = 0; i < MAX_OPEN; i++) {
  369. !         if (orfd & mask) {
  370.               f = p->handle[i];
  371.               if (f)
  372.                   (*f->dev->unselect)(f, (long)p, O_RDONLY);
  373.           }
  374. !         if (owfd & mask) {
  375.               f = p->handle[i];
  376.               if (f)
  377.                   (*f->dev->unselect)(f, (long)p, O_WRONLY);
  378. ***************
  379. *** 1091,1096 ****
  380. --- 1129,1138 ----
  381.           mask = mask << 1L;
  382.       }
  383.   
  384. +     /* wake other processes which got a collision */
  385. +     if (orfd || owfd)
  386. +         wake(SELECT_Q, (long)&select_coll);
  387. + 
  388.       TRACE(("Fselect: returning %d", count));
  389.       return count;
  390.   }
  391. *** ../new/pipefs.c    Fri Oct 22 20:58:28 1993
  392. --- pipefs.c    Mon Sep 13 21:44:34 1993
  393. ***************
  394. *** 1010,1018 ****
  395.               return 1;
  396.           }
  397.   
  398. ! /* BUG: multiple selects fail, only the first one works */
  399. !         if (!p->rsel)
  400. !             p->rsel = proc;
  401.           return 0;
  402.       } else if (mode == O_WRONLY) {
  403.           p = (f->flags & O_HEAD) ? this->inp : this->outp;
  404. --- 1010,1018 ----
  405.               return 1;
  406.           }
  407.   
  408. !         if (p->rsel)
  409. !             return 2; /* collision */
  410. !         p->rsel = proc;
  411.           return 0;
  412.       } else if (mode == O_WRONLY) {
  413.           p = (f->flags & O_HEAD) ? this->inp : this->outp;
  414. ***************
  415. *** 1024,1031 ****
  416.           if (j >= PIPESIZ) j = 0;
  417.           if (j != p->head || p->readers <= 0)
  418.               return 1;    /* data may be written */
  419. !         if (!p->wsel)
  420. !             p->wsel = proc;
  421.           return 0;
  422.       }
  423.       return 0;
  424. --- 1024,1032 ----
  425.           if (j >= PIPESIZ) j = 0;
  426.           if (j != p->head || p->readers <= 0)
  427.               return 1;    /* data may be written */
  428. !         if (p->wsel)
  429. !             return 2; /* collsion */
  430. !         p->wsel = proc;
  431.           return 0;
  432.       }
  433.       return 0;
  434. *** ../new/proc.c    Fri Oct 22 20:59:28 1993
  435. --- proc.c    Fri Oct 22 19:58:24 1993
  436. ***************
  437. *** 612,620 ****
  438.   {
  439.       PROC *p = (PROC *)param;
  440.       short s;
  441. ! 
  442.       s = spl7();    /* block interrupts */
  443. !     if(p->wait_cond == (long)wakeselect) {
  444.           p->wait_cond = 0;
  445.       }
  446.       if (p->wait_q == SELECT_Q) {
  447. --- 612,622 ----
  448.   {
  449.       PROC *p = (PROC *)param;
  450.       short s;
  451. !     extern short select_coll; /* in dosfile.c */
  452. !     
  453.       s = spl7();    /* block interrupts */
  454. !     if(p->wait_cond == (long)wakeselect ||
  455. !        p->wait_cond == (long)&select_coll) {
  456.           p->wait_cond = 0;
  457.       }
  458.       if (p->wait_q == SELECT_Q) {
  459. *** ../new/signal.c    Fri Oct 22 20:59:36 1993
  460. --- signal.c    Fri Oct 22 20:58:10 1993
  461. ***************
  462. *** 85,93 ****
  463.   
  464.   /* otherwise, make sure the process is awake */
  465.       if (p->wait_q && p->wait_q != READY_Q) {
  466. !         short sr = spl7();
  467. !         if (p->wait_q == SELECT_Q)
  468. !             p->wait_cond = 0;
  469.           rm_q(p->wait_q, p);
  470.           add_q(READY_Q, p);
  471.           spl(sr);
  472. --- 85,91 ----
  473.   
  474.   /* otherwise, make sure the process is awake */
  475.       if (p->wait_q && p->wait_q != READY_Q) {
  476. !         sr = spl7();
  477.           rm_q(p->wait_q, p);
  478.           add_q(READY_Q, p);
  479.           spl(sr);
  480.  
  481.